
//
// !!!修改文件后调用 npm run buildJs 生成 global-utils-all.js
//

"use strict";

import { globalUtils, _privateFn } from './global-utils-core';

/* SOURCE-CODE-START */

//
// 判断给定的参数是什么类型
//

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是字符串类型
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值是字符串则返回 true, 否则返回 false 
 */
globalUtils.isString = function (arg) {
  return (typeof arg === 'string');
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是数字类型
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值是数字则返回 true, 否则返回 false 
 */
globalUtils.isNumber = function (arg) {
  return (typeof arg === 'number');
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是布尔值类型
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值是布尔值则返回 true, 否则返回 false 
 */
globalUtils.isBoolean = function (arg) {
  return (typeof arg === 'boolean');
};

/**
 * @memberof globalUtils
 * @param {*} [arg] 判断给定参数的值是不是对象(包括 null 值)
 * @returns {boolean} 若给定参数的值是对象则返回 true, 反则返回 false
 */
globalUtils.isObject = function (arg) {
  return (typeof arg === 'object');
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是函数
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值是函数则返回 true, 反则返回 false
 */
globalUtils.isFunction = function (arg) {
  return (typeof arg === 'function');
};

/**
 * @memberof globalUtils
 * @param {*} [arg] 判断给定参数的值是不是数组
 * @returns {boolean} 若给定参数的值是数组则返回 true, 反则返回 false
 */
globalUtils.isArray = function (arg) {
  return (arg instanceof Array);
};

/**
 * @memberof globalUtils
 * @param {*} [arg] 判断给定参数的值是不是日期
 * @returns {boolean} 若给定参数的值是日期则返回 true, 反则返回 false
 */
globalUtils.isDate = function (arg) {
  return (arg instanceof Date);
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是 null/undefined
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值是 null/undefined 则返回 true, 否则返回 false
 */
globalUtils.isNullOrUndefined = function (arg) {
  return (arg === null || arg === undefined);
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是空字符
 * @param {*} [arg] 
 * @returns {boolean} 若给定参数的值不是空字符串则返回 true, 否则返回 false
 */
globalUtils.isNotEmptyString = function (arg) {
  return (globalUtils.isString(arg) && arg.length > 0);
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是空数组
 * @param {*} [arg]
 * @returns {boolean} 若给定参数的值不是空数组则返回 true, 否则返回 false
 */
globalUtils.isNotEmptyArray = function (arg) {
  return (globalUtils.isArray(arg) && (arg.length > 0));
};

/**
 * @memberof globalUtils
 * @description 判断给定参数的值是不是空对象
 * @param {*} [arg]
 * @returns {boolean} 若给定参数的值不是空对象则返回 true, 否则返回 false
 */
globalUtils.isNotEmptyObject = function (arg) {
  if (globalUtils.isNullOrUndefined(arg) || !globalUtils.isObject(arg)) {
    return false;
  }

  for (var key in arg) {
    return true;
  }

  return false;
};

//
// 提供返回默认值的方法
//

/**
 * @memberof globalUtils
 * @description 若第一个参数不是 null/undefined 则返回第一个参数，否则返回空字符串
 * @param {*} [arg]
 * @returns {string}
 */
globalUtils.emptyStringIfNullOrUndefined = function (arg) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return '';
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 若第一个参数不是 null/undefined 则返回第一个参数，否则返回空数组
 * @param {*} [arg]
 * @returns {Array}
 */
globalUtils.emptyArrayIfNullOrUndefined = function (arg) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return [];
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 若第一个参数不是 null/undefined 则返回第一个参数，否则返回空对象
 * @param {*} [arg]
 * @returns {object}
 */
globalUtils.emptyObjectIfNullOrUndefined = function (arg) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return {};
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 若第一个参数不是 null/undefined 则返回第一个参数，否则返回默认值
 * @param {*} [arg]
 * @param {*} [defaultValue]
 * @returns {object}
 */
globalUtils.defaultValueIfNullOrUndefined = function (arg, defaultValue) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return defaultValue;
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 若第一个参数的值是 null 或者去掉空白符为空则返回默认值，否则返回第一个参数的值
 * @param {*} [arg]
 * @param {*} [defaultValue]
 * @returns {*}
 */
globalUtils.defaultValueIfBlankString = function (arg, defaultValue) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return defaultValue;
  }

  if (globalUtils.isString(arg)) {
    var trimedString = globalUtils.trimString(arg);

    if (trimedString.length <= 0) {
      return defaultValue;
    }
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 若第一个参数的值是 null 或者是空字符串则返回默认值，否则返回第一个参数的值
 * @param {*} [arg]
 * @param {*} [defaultValue]
 * @returns {*}
 */
globalUtils.defaultValueIfEmptyString = function (arg, defaultValue) {
  if (globalUtils.isNullOrUndefined(arg)) {
    return defaultValue;
  }

  if (globalUtils.isString(arg) && arg.length <= 0) {
    return defaultValue;
  }

  return arg;
};


//
// 处理字符串和对象的方法
//

/**
 * @memberof globalUtils
 * @description 转换给定参数的值成字符串
 * @param {*} [arg]
 * @returns {string} 若参数的值不是 null/undefined 则返回字符串，否则返回 null/undefined
 */
globalUtils.convertToString = function (arg) {
  if (globalUtils.isString(arg)) {
    return arg;
  }

  if (globalUtils.isNullOrUndefined(arg)) {
    return arg;
  }

  return String(arg);
};

/**
 * @memberof globalUtils
 * @description 删除给定参数的值的头尾空白符
 * @param {*} [arg]
 * @returns {*} 若参数的值不是字符串则直接返回，否则返回去掉头尾空白符的字符串
 */
globalUtils.trimString = function (arg) {
  if (globalUtils.isString(arg)) {
    return arg.trim();
  }

  return arg;
};

/**
 * @memberof globalUtils
 * @description 根据给定的字符串格式和参数做字符串格式化
 * @param {string} format 字符串格式的占位符是 {0}、{1}、{2} ...
 * @param {(string[]|...string)} args
 * @returns {string} 返回字符串格式化后的字符串
 */
globalUtils.formatString = function (format, objectArray) {
  if (globalUtils.isNullOrUndefined(format)) {
    throw new Error('argument#0 "format" is null/undefined');
  }

  if (!globalUtils.isString(format)) {
    throw new Error('argument#0 "format" required string');
  }

  if (!(objectArray instanceof Array)) {
    objectArray = [];

    for (var index = 1; index < arguments.length; index++) {
      objectArray.push(arguments[index]);
    }
  }

  // 替换占位符 {数字}
  var newString = format.replace(/\{([0-9]+)\}/g, function (match, index) {
    var argIndex = parseInt(index);
    var arg = objectArray[argIndex];

    return (globalUtils.convertToString(arg) || '');
  });

  return newString;
};


/* SOURCE-CODE-END */

export { globalUtils, _privateFn };
